package rhc.taskSchedule.util;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import rhc.taskSchedule.exception.NormalException;

/**json参数工具类
 * @author rhc
 *
 */
public class JsonParameterUtil {

	/**将json字符串转换为map，同时检测必须包含的参数
	 * @param json
	 * @param mustContainsKey
	 * @return
	 * @throws Exception
	 */
	public static Map<String,Object> jsonToMap(String json,String...mustContainsKey) throws Exception{
		
		if(null != mustContainsKey && mustContainsKey.length > 0 && StringUtils.isEmpty(json)){
			throw new NormalException("参数不能为空");
		}
		
		if(StringUtils.isEmpty(json)){
			return null;
		}
		
		Map<String,Object> parameter=null;
		try{
			parameter=NormalUtil.jsonToJavaBean(json, Map.class);
		}catch(Exception e){
			throw new NormalException("参数格式不正确");
		}
		if(null != parameter && null != mustContainsKey && mustContainsKey.length > 0){
			for(String mk:mustContainsKey){
				if(parameter.containsKey(mk)){
					continue;
				}
				throw new NormalException("参数 "+mk+" 不能为空");
			}
		}
		return parameter;
	}
	
	/**获取map里的key，
	 * @param parameter 
	 * @param key 
	 * @param defaultValue 当没有该key或为空时返回默认字段
	 * @param canNull 是否可以为空
	 * @return
	 * @throws NormalException
	 */
	public static <T> T getParameter(Map<String,Object> parameter,String key,T defaultValue,boolean canNull,Class<T> distClass) throws Exception{
		
		if((null == parameter && !canNull) || StringUtils.isEmpty(key)){
			throw new NormalException("不能为空");
		}
		
		Object value=null==parameter?null:parameter.get(key);
		if(null == value){
			if(!canNull){
				throw new NormalException("参数 "+key+" 不能为空");
			}
			return defaultValue;
		}else{
			validateValueIsClass(key,value,distClass);
			T t=(T) value;
			return t;
		}
	}
	
	/**验证value是否是distClass类型
	 * @param key
	 * @param value
	 * @param distClass
	 */
	private static void validateValueIsClass(String key,Object value,Class distClass) throws Exception{
		if(null != distClass && null != value && !(distClass.isAssignableFrom(value.getClass()))){
			throw new NormalException(key+" must be "+distClass.getSimpleName()+",not "+value.getClass().getSimpleName());
		}
	}
	
	/**检查一个值是否是允许的值中的一个
	 * @param parameter
	 * @param key
	 * @param valueArr
	 * @param canNull
	 * @throws NormalException
	 */
	public static <T> void validateValueIsInEnum(Map<String,Object> parameter,String key,T[] valueEnum,boolean canNull,Class<T> distClass) throws Exception{
		Object value=null;
		if(null == parameter || null == (value=parameter.get(key))) {
			if(!canNull){
				throw new NormalException(key+" 不能为空");
			}
			return;
		}
		
		validateValueIsClass(key,value,distClass);
		validateValueIsEnum(key,value,valueEnum,canNull);
	}
	
	/**检验一个值是否是允许的值中的一个
	 * @param value
	 * @param valueEnum
	 * @param canNull
	 * @throws NormalException
	 */
	public static <T> void validateValueIsEnum(String key,T value,T[] valueEnum,boolean canNull) throws Exception{
		
		if(null == value || (value instanceof String && StringUtils.isEmpty((String)value))){
			if(!canNull){
				throw new NormalException(key+" 不能为空");
			}else{
				return;
			}
		}
		
		if(null == valueEnum || valueEnum.length == 0){
			return;
		}
		
		Set<T> valueSet=new HashSet<T>(Arrays.asList(valueEnum));
		String str=NormalUtil.join(valueSet, ",");
		if(!valueSet.contains(value)){
			throw new NormalException(key+" 必须为给定值中的一个,"+str);
		}
		
	}
	
	/**验证必须包含多少key不为空
	 * @param parameter
	 * @param needKeyCount
	 * @param keys
	 * @throws Exception 
	 */
	public static void validateMustNeedKey(Map<String,Object> parameter,int needKeyCount,String... keys) throws Exception{
		
		if(null == keys || keys.length == 0){
			return;
		}
		
		int notNullCount=0;
		for(String key:keys){
			if(null != getParameter(parameter,key,null,true,Object.class)){
				notNullCount++;
				if(notNullCount>=needKeyCount){
					return;
				}
			}
		}
		
		String keysStr=NormalUtil.join(keys,",");
		
		throw new NormalException(keysStr+" 必须有"+needKeyCount+"不为空");
	}
	
	public static void main(String[] args){
		
		Object aa="cc";
		Map<String,Object> parameter=new HashMap<String,Object>();
		parameter.put("bb", 1111);
		try{
			String cc=JsonParameterUtil.getParameter(parameter, "bb", null, false,String.class);
		}catch(Exception e){
			System.out.println("success,"+e.getMessage());
			e.printStackTrace();
		}
	}
}
